/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
    * in compliance with the License. You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software distributed under the License
   * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
   * or implied. See the License for the specific language governing permissions and limitations under
   * the License.
   */
  
  package com.google.common.cache;
  
  import com.google.common.base.Function;
  import com.google.common.base.MoreObjects;
  import com.google.common.base.Objects;
  import com.google.common.base.Optional;
  import com.google.common.base.Preconditions;
  import com.google.common.cache.LocalCache.Strength;
  import com.google.common.collect.Iterables;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Sets;
  
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  
  import javax.annotation.Nullable;
  
  /**
   * Helper class for creating {@link CacheBuilder} instances with all combinations of several sets of
   * parameters.
   *
   * @author mike nonemacher
   */
  class CacheBuilderFactory {
    // Default values contain only 'null', which means don't call the CacheBuilder method (just give
    // the CacheBuilder default).
    private Set<Integer> concurrencyLevels = Sets.newHashSet((Integer) null);
    private Set<Integer> initialCapacities = Sets.newHashSet((Integer) null);
    private Set<Integer> maximumSizes = Sets.newHashSet((Integer) null);
    private Set<DurationSpec> expireAfterWrites = Sets.newHashSet((DurationSpec) null);
    private Set<DurationSpec> expireAfterAccesses = Sets.newHashSet((DurationSpec) null);
    private Set<DurationSpec> refreshes = Sets.newHashSet((DurationSpec) null);
    private Set<Strength> keyStrengths = Sets.newHashSet((Strength) null);
    private Set<Strength> valueStrengths = Sets.newHashSet((Strength) null);
  
    CacheBuilderFactory withConcurrencyLevels(Set<Integer> concurrencyLevels) {
      this.concurrencyLevels = Sets.newLinkedHashSet(concurrencyLevels);
      return this;
    }
  
    CacheBuilderFactory withInitialCapacities(Set<Integer> initialCapacities) {
      this.initialCapacities = Sets.newLinkedHashSet(initialCapacities);
      return this;
    }
  
    CacheBuilderFactory withMaximumSizes(Set<Integer> maximumSizes) {
      this.maximumSizes = Sets.newLinkedHashSet(maximumSizes);
      return this;
    }
  
    CacheBuilderFactory withExpireAfterWrites(Set<DurationSpec> durations) {
      this.expireAfterWrites = Sets.newLinkedHashSet(durations);
      return this;
    }
  
    CacheBuilderFactory withExpireAfterAccesses(Set<DurationSpec> durations) {
      this.expireAfterAccesses = Sets.newLinkedHashSet(durations);
      return this;
    }
  
    CacheBuilderFactory withRefreshes(Set<DurationSpec> durations) {
      this.refreshes = Sets.newLinkedHashSet(durations);
      return this;
    }
  
    CacheBuilderFactory withKeyStrengths(Set<Strength> keyStrengths) {
      this.keyStrengths = Sets.newLinkedHashSet(keyStrengths);
      Preconditions.checkArgument(!this.keyStrengths.contains(Strength.SOFT));
      return this;
    }
  
    CacheBuilderFactory withValueStrengths(Set<Strength> valueStrengths) {
      this.valueStrengths = Sets.newLinkedHashSet(valueStrengths);
      return this;
    }
  
    Iterable<CacheBuilder<Object, Object>> buildAllPermutations() {
      @SuppressWarnings("unchecked")
      Iterable<List<Object>> combinations = buildCartesianProduct(concurrencyLevels,
          initialCapacities, maximumSizes, expireAfterWrites, expireAfterAccesses, refreshes,
          keyStrengths, valueStrengths);
      return Iterables.transform(combinations,
          new Function<List<Object>, CacheBuilder<Object, Object>>() {
            @Override public CacheBuilder<Object, Object> apply(List<Object> combination) {
             return createCacheBuilder(
                 (Integer) combination.get(0),
                 (Integer) combination.get(1),
                 (Integer) combination.get(2),
                 (DurationSpec) combination.get(3),
                 (DurationSpec) combination.get(4),
                 (DurationSpec) combination.get(5),
                 (Strength) combination.get(6),
                 (Strength) combination.get(7));
           }
         });
   }
 
   private static final Function<Object, Optional<?>> NULLABLE_TO_OPTIONAL =
       new Function<Object, Optional<?>>() {
         @Override public Optional<?> apply(@Nullable Object obj) {
           return Optional.fromNullable(obj);
         }
       };
 
   private static final Function<Optional<?>, Object> OPTIONAL_TO_NULLABLE =
       new Function<Optional<?>, Object>() {
         @Override public Object apply(Optional<?> optional) {
           return optional.orNull();
         }
       };
 
   /**
    * Sets.cartesianProduct doesn't allow sets that contain null, but we want null to mean
    * "don't call the associated CacheBuilder method" - that is, get the default CacheBuilder
    * behavior. This method wraps the elements in the input sets (which may contain null) as
    * Optionals, calls Sets.cartesianProduct with those, then transforms the result to unwrap
    * the Optionals. 
    */
   private Iterable<List<Object>> buildCartesianProduct(Set<?>... sets) {
     List<Set<Optional<?>>> optionalSets = Lists.newArrayListWithExpectedSize(sets.length);
     for (Set<?> set : sets) {
       Set<Optional<?>> optionalSet =
           Sets.newLinkedHashSet(Iterables.transform(set, NULLABLE_TO_OPTIONAL));
       optionalSets.add(optionalSet);
     }
     Set<List<Optional<?>>> cartesianProduct = Sets.cartesianProduct(optionalSets);
     return Iterables.transform(cartesianProduct,
         new Function<List<Optional<?>>, List<Object>>() {
           @Override public List<Object> apply(List<Optional<?>> objs) {
             return Lists.transform(objs, OPTIONAL_TO_NULLABLE);
           }
         });
   }
 
   private CacheBuilder<Object, Object> createCacheBuilder(
       Integer concurrencyLevel, Integer initialCapacity, Integer maximumSize,
       DurationSpec expireAfterWrite, DurationSpec expireAfterAccess, DurationSpec refresh,
       Strength keyStrength, Strength valueStrength) {
 
     CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
     if (concurrencyLevel != null) {
       builder.concurrencyLevel(concurrencyLevel);
     }
     if (initialCapacity != null) {
       builder.initialCapacity(initialCapacity);
     }
     if (maximumSize != null) {
       builder.maximumSize(maximumSize);
     }
     if (expireAfterWrite != null) {
       builder.expireAfterWrite(expireAfterWrite.duration, expireAfterWrite.unit);
     }
     if (expireAfterAccess != null) {
       builder.expireAfterAccess(expireAfterAccess.duration, expireAfterAccess.unit);
     }
     if (refresh != null) {
       builder.refreshAfterWrite(refresh.duration, refresh.unit);
     }
     if (keyStrength != null) {
       builder.setKeyStrength(keyStrength);
     }
     if (valueStrength != null) {
       builder.setValueStrength(valueStrength);
     }
     return builder;
   }
 
   static class DurationSpec {
     private final long duration;
     private final TimeUnit unit;
 
     private DurationSpec(long duration, TimeUnit unit) {
       this.duration = duration;
       this.unit = unit;
     }
 
     public static DurationSpec of(long duration, TimeUnit unit) {
       return new DurationSpec(duration, unit);
     }
 
     @Override
     public int hashCode() {
       return Objects.hashCode(duration, unit);
     }
 
     @Override
     public boolean equals(Object o) {
       if (o instanceof DurationSpec) {
         DurationSpec that = (DurationSpec) o;
         return unit.toNanos(duration) == that.unit.toNanos(that.duration);
       }
       return false;
     }
 
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("duration", duration)
           .add("unit", unit)
           .toString();
     }
   }
 }